"""
IP管理模块回归测试脚本
用于验证IP管理模块的完整功能和避免外键导入数据插入问题
"""

import sys
import os
import time
import logging
from datetime import datetime

# 添加项目根目录到Python路径
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '.'))

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('ip_regression_test.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

class IpRegressionTest:
    """IP管理模块回归测试类"""
    
    def __init__(self):
        self.test_results = []
        self.test_data = {}
        self.setup_test_data()
    
    def setup_test_data(self):
        """设置测试数据"""
        self.test_data = {
            'valid_ips': [
                {
                    'ip': '192.168.10.10',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN10',
                    'purpose': '管理',
                    'status': '使用中',
                    'allocation_duration': '永久',
                    'hostname': 'server-01',
                    'description': '主服务器管理IP',
                    'asset_id': '2692be71-2cef-4b5d-9379-1e6f6033b7af'
                },
                {
                    'ip': '192.168.10.11',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN10',
                    'purpose': '业务',
                    'status': '使用中',
                    'allocation_duration': '永久',
                    'hostname': 'app-server-01',
                    'description': '应用服务器IP',
                    'os_id': 'eda89e1f-1774-43e6-8fbe-db4628bdfc7e'
                },
                {
                    'ip': '192.168.20.10',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN20',
                    'purpose': '存储',
                    'status': '使用中',
                    'allocation_duration': '永久',
                    'hostname': 'storage-01',
                    'description': '存储服务器IP',
                    'system_id': '01c69240-3efd-4e40-863c-ce6af484e149'
                }
            ],
            'invalid_ips': [
                {
                    'ip': 'invalid.ip.address',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN10',
                    'purpose': '管理',
                    'status': '使用中',
                    'allocation_duration': '永久'
                },
                {
                    'ip': '192.168.10.12',
                    'subnet_mask': 'invalid.mask',
                    'vlan': 'VLAN10',
                    'purpose': '管理',
                    'status': '使用中',
                    'allocation_duration': '永久'
                }
            ],
            'entity_binding_data': [
                {
                    'ip': '192.168.10.20',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN10',
                    'purpose': '管理',
                    'status': '使用中',
                    'allocation_duration': '永久',
                    'asset_id': '46fd9b3b-a70a-48cf-95fc-f918c94fbfd9',
                    'hostname': 'asset-server-01',
                    'description': '绑定到设备资产的IP'
                },
                {
                    'ip': '192.168.10.21',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN10',
                    'purpose': '业务',
                    'status': '使用中',
                    'allocation_duration': '永久',
                    'os_id': 'eda89e1f-1774-43e6-8fbe-db4628bdfc7e',
                    'hostname': 'os-server-01',
                    'description': '绑定到操作系统的IP'
                },
                {
                    'ip': '192.168.10.22',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN10',
                    'purpose': '业务',
                    'status': '使用中',
                    'allocation_duration': '永久',
                    'system_id': '01c69240-3efd-4e40-863c-ce6af484e149',
                    'hostname': 'system-server-01',
                    'description': '绑定到业务系统的IP'
                }
            ]
        }
    
    def run_test(self, test_name, test_func):
        """运行单个测试"""
        logger.info(f"开始测试: {test_name}")
        start_time = time.time()
        
        try:
            result = test_func()
            end_time = time.time()
            
            test_result = {
                'name': test_name,
                'status': 'PASS' if result else 'FAIL',
                'duration': end_time - start_time,
                'message': '测试通过' if result else '测试失败'
            }
            
            self.test_results.append(test_result)
            logger.info(f"测试 {test_name}: {test_result['status']} ({test_result['duration']:.2f}s)")
            
        except Exception as e:
            end_time = time.time()
            test_result = {
                'name': test_name,
                'status': 'ERROR',
                'duration': end_time - start_time,
                'message': f"测试异常: {str(e)}"
            }
            
            self.test_results.append(test_result)
            logger.error(f"测试 {test_name}: ERROR - {str(e)}")
    
    def test_import_modules(self):
        """测试模块导入"""
        try:
            from src.app.modules.ip.service import IpService
            from src.app.modules.ip.cache import IpCache
            from src.app.modules.ip.utils import IpUtils
            
            # 测试实例化
            service = IpService()
            cache = IpCache()
            utils = IpUtils()
            
            logger.info("所有模块导入成功")
            return True
            
        except ImportError as e:
            logger.error(f"模块导入失败: {e}")
            return False
    
    def test_utils_validation(self):
        """测试工具类验证功能"""
        try:
            from src.app.modules.ip.utils import IpUtils
            utils = IpUtils()
            
            # 测试有效IP数据验证
            for ip_data in self.test_data['valid_ips']:
                is_valid, error_msg = utils.validate_ip_data(ip_data)
                if not is_valid:
                    logger.error(f"有效IP数据验证失败: {ip_data['ip']} - {error_msg}")
                    return False
            
            # 测试无效IP数据验证
            for ip_data in self.test_data['invalid_ips']:
                is_valid, error_msg = utils.validate_ip_data(ip_data)
                if is_valid:
                    logger.error(f"无效IP数据验证应该失败: {ip_data['ip']}")
                    return False
            
            # 测试IP格式验证
            assert utils.is_valid_ip('192.168.1.1') == True
            assert utils.is_valid_ip('256.256.256.256') == False
            
            # 测试子网掩码验证
            assert utils.is_valid_subnet_mask('255.255.255.0') == True
            assert utils.is_valid_subnet_mask('255.255.255.1') == False
            
            # 测试VLAN验证
            assert utils.is_valid_vlan('VLAN100') == True
            assert utils.is_valid_vlan('100') == True
            assert utils.is_valid_vlan('INVALID') == False
            
            # 测试VLAN标准化
            assert utils.normalize_vlan('100') == 'VLAN100'
            assert utils.normalize_vlan('VLAN100') == 'VLAN100'
            
            logger.info("工具类验证功能测试通过")
            return True
            
        except Exception as e:
            logger.error(f"工具类验证功能测试失败: {e}")
            return False
    
    def test_cache_operations(self):
        """测试缓存操作"""
        try:
            from src.app.modules.ip.cache import IpCache
            cache = IpCache(cache_timeout=2)  # 2秒超时
            
            # 测试IP缓存
            test_ip_data = self.test_data['valid_ips'][0]
            cache.set_ip(test_ip_data['ip'], test_ip_data)
            
            cached_data = cache.get_ip(test_ip_data['ip'])
            if cached_data is None or cached_data['ip'] != test_ip_data['ip']:
                logger.error("IP缓存设置或获取失败")
                return False
            
            # 测试统计信息缓存
            test_stats = {'total_count': 100, 'status_distribution': {'使用中': 50}}
            cache.set_statistics(test_stats)
            
            cached_stats = cache.get_statistics()
            if cached_stats is None or cached_stats['total_count'] != 100:
                logger.error("统计信息缓存设置或获取失败")
                return False
            
            # 测试IP列表缓存
            test_list = self.test_data['valid_ips']
            filters_hash = cache.generate_filters_hash({'vlan': 'VLAN10'})
            cache.set_ip_list(filters_hash, test_list)
            
            cached_list = cache.get_ip_list(filters_hash)
            if cached_list is None or len(cached_list) != len(test_list):
                logger.error("IP列表缓存设置或获取失败")
                return False
            
            # 测试缓存过期
            time.sleep(2.1)
            cached_data = cache.get_ip(test_ip_data['ip'])
            if cached_data is not None:
                logger.error("缓存过期机制失效")
                return False
            
            # 测试缓存清除
            cache.set_ip(test_ip_data['ip'], test_ip_data)
            cache.clear_cache()
            cached_data = cache.get_ip(test_ip_data['ip'])
            if cached_data is not None:
                logger.error("缓存清除失败")
                return False
            
            logger.info("缓存操作测试通过")
            return True
            
        except Exception as e:
            logger.error(f"缓存操作测试失败: {e}")
            return False
    
    def test_service_crud_operations(self):
        """测试服务层CRUD操作"""
        try:
            from src.app.modules.ip.service import IpService
            service = IpService()
            
            # 清理可能存在的测试数据
            for ip_data in self.test_data['valid_ips']:
                try:
                    service.delete_ip(ip_data['ip'])
                except:
                    pass
            
            # 测试创建IP
            for ip_data in self.test_data['valid_ips']:
                result = service.create_ip(ip_data)
                if not result['success']:
                    logger.error(f"创建IP失败: {ip_data['ip']} - {result['message']}")
                    return False
            
            # 测试获取IP
            for ip_data in self.test_data['valid_ips']:
                retrieved_data = service.get_ip_by_ip(ip_data['ip'])
                if retrieved_data is None or retrieved_data['ip'] != ip_data['ip']:
                    logger.error(f"获取IP失败: {ip_data['ip']}")
                    return False
            
            # 测试更新IP
            update_data = {'status': '预留', 'description': '更新后的描述'}
            test_ip = self.test_data['valid_ips'][0]['ip']
            result = service.update_ip(test_ip, update_data)
            if not result['success']:
                logger.error(f"更新IP失败: {test_ip} - {result['message']}")
                return False
            
            # 验证更新结果
            updated_data = service.get_ip_by_ip(test_ip)
            if updated_data['status'] != '预留' or updated_data['description'] != '更新后的描述':
                logger.error(f"IP更新验证失败: {test_ip}")
                return False
            
            # 测试获取所有IP
            all_ips = service.get_all_ips()
            if len(all_ips) < len(self.test_data['valid_ips']):
                logger.error("获取所有IP失败")
                return False
            
            # 测试筛选功能
            vlan10_ips = service.get_all_ips({'vlan': 'VLAN10'})
            if len(vlan10_ips) < 2:
                logger.error("VLAN筛选功能失败")
                return False
            
            # 测试统计信息
            statistics = service.get_ip_statistics()
            if 'total_count' not in statistics or 'status_distribution' not in statistics:
                logger.error("统计信息获取失败")
                return False
            
            # 测试删除IP
            for ip_data in self.test_data['valid_ips']:
                result = service.delete_ip(ip_data['ip'])
                if not result['success']:
                    logger.error(f"删除IP失败: {ip_data['ip']} - {result['message']}")
                    return False
            
            # 验证删除结果
            for ip_data in self.test_data['valid_ips']:
                retrieved_data = service.get_ip_by_ip(ip_data['ip'])
                if retrieved_data is not None:
                    logger.error(f"IP删除验证失败: {ip_data['ip']}")
                    return False
            
            logger.info("服务层CRUD操作测试通过")
            return True
            
        except Exception as e:
            logger.error(f"服务层CRUD操作测试失败: {e}")
            return False
    
    def test_entity_binding(self):
        """测试实体绑定功能"""
        try:
            from src.app.modules.ip.service import IpService
            from src.app.modules.ip.utils import IpUtils
            service = IpService()
            utils = IpUtils()
            
            # 清理可能存在的测试数据
            for ip_data in self.test_data['entity_binding_data']:
                try:
                    service.delete_ip(ip_data['ip'])
                except:
                    pass
            
            # 测试创建绑定到不同实体的IP
            for ip_data in self.test_data['entity_binding_data']:
                result = service.create_ip(ip_data)
                if not result['success']:
                    logger.error(f"创建绑定IP失败: {ip_data['ip']} - {result['message']}")
                    return False
            
            # 测试获取绑定实体信息
            for ip_data in self.test_data['entity_binding_data']:
                entity_info = service.get_binding_entities(ip_data['ip'])
                if entity_info is None:
                    logger.error(f"获取绑定实体信息失败: {ip_data['ip']}")
                    return False
                
                # 验证绑定类型
                expected_type = utils.get_binding_entity_type(ip_data)
                actual_type = list(entity_info.keys())[0]
                # 修正验证逻辑：比较英文键名而不是中文描述
                type_mapping = {
                    '设备资产': 'asset',
                    '操作系统': 'os',
                    '业务系统': 'system',
                    '中间件': 'middleware',
                    '带外管理': 'oob'
                }
                expected_key = type_mapping.get(expected_type)
                if expected_key != actual_type:
                    logger.error(f"绑定类型验证失败: {ip_data['ip']} - 期望: {expected_key} ({expected_type}), 实际: {actual_type}")
                    return False
            
            # 测试多实体绑定验证（应该失败）
            invalid_binding_data = self.test_data['entity_binding_data'][0].copy()
            invalid_binding_data['ip'] = '192.168.10.30'
            invalid_binding_data['os_id'] = 'eda89e1f-1774-43e6-8fbe-db4628bdfc7e'  # 同时绑定到资产和操作系统
            
            result = service.create_ip(invalid_binding_data)
            if result['success']:
                logger.error("多实体绑定验证失败，应该拒绝创建")
                return False
            
            # 清理测试数据
            for ip_data in self.test_data['entity_binding_data']:
                try:
                    service.delete_ip(ip_data['ip'])
                except:
                    pass
            
            logger.info("实体绑定功能测试通过")
            return True
            
        except Exception as e:
            logger.error(f"实体绑定功能测试失败: {e}")
            return False
    
    def test_foreign_key_constraints(self):
        """测试外键约束（重点测试外键导入数据不能插入的问题）"""
        try:
            from src.app.modules.ip.service import IpService
            service = IpService()
            
            # 测试1: 绑定到不存在的设备资产
            invalid_asset_ip = {
                'ip': '192.168.10.100',
                'subnet_mask': '255.255.255.0',
                'vlan': 'VLAN10',
                'purpose': '管理',
                'status': '使用中',
                'allocation_duration': '永久',
                'asset_id': 'NONEXISTENT_ASSET_001'
            }
            
            result = service.create_ip(invalid_asset_ip)
            if result['success']:
                logger.error("绑定到不存在设备资产应该失败")
                return False
            
            # 测试2: 绑定到不存在的操作系统
            invalid_os_ip = {
                'ip': '192.168.10.101',
                'subnet_mask': '255.255.255.0',
                'vlan': 'VLAN10',
                'purpose': '管理',
                'status': '使用中',
                'allocation_duration': '永久',
                'os_id': 'NONEXISTENT_OS_001'
            }
            
            result = service.create_ip(invalid_os_ip)
            if result['success']:
                logger.error("绑定到不存在操作系统应该失败")
                return False
            
            # 测试3: 绑定到不存在的业务系统
            invalid_system_ip = {
                'ip': '192.168.10.102',
                'subnet_mask': '255.255.255.0',
                'vlan': 'VLAN10',
                'purpose': '管理',
                'status': '使用中',
                'allocation_duration': '永久',
                'system_id': 'NONEXISTENT_SYSTEM_001'
            }
            
            result = service.create_ip(invalid_system_ip)
            if result['success']:
                logger.error("绑定到不存在业务系统应该失败")
                return False
            
            # 测试4: 绑定到不存在的中间件
            invalid_middleware_ip = {
                'ip': '192.168.10.103',
                'subnet_mask': '255.255.255.0',
                'vlan': 'VLAN10',
                'purpose': '管理',
                'status': '使用中',
                'allocation_duration': '永久',
                'mw_id': 'NONEXISTENT_MW_001'
            }
            
            result = service.create_ip(invalid_middleware_ip)
            if result['success']:
                logger.error("绑定到不存在中间件应该失败")
                return False
            
            # 测试5: 绑定到不存在的带外管理
            invalid_oob_ip = {
                'ip': '192.168.10.104',
                'subnet_mask': '255.255.255.0',
                'vlan': 'VLAN10',
                'purpose': '管理',
                'status': '使用中',
                'allocation_duration': '永久',
                'oob_id': 'NONEXISTENT_OOB_001'
            }
            
            result = service.create_ip(invalid_oob_ip)
            if result['success']:
                logger.error("绑定到不存在带外管理应该失败")
                return False
            
            # 测试6: 创建绑定到有效实体的IP（应该成功）
            valid_bound_ip = {
                'ip': '192.168.10.105',
                'subnet_mask': '255.255.255.0',
                'vlan': 'VLAN10',
                'purpose': '管理',
                'status': '使用中',
                'allocation_duration': '永久',
                'asset_id': '2692be71-2cef-4b5d-9379-1e6f6033b7af',
                'description': '绑定到有效实体的IP'
            }
            
            result = service.create_ip(valid_bound_ip)
            if not result['success']:
                logger.error(f"创建绑定实体的IP失败: {result['message']}")
                return False
            
            # 清理测试数据
            try:
                service.delete_ip(valid_bound_ip['ip'])
            except:
                pass
            
            logger.info("外键约束测试通过")
            return True
            
        except Exception as e:
            logger.error(f"外键约束测试失败: {e}")
            return False
    
    def test_batch_operations(self):
        """测试批量操作"""
        try:
            from src.app.modules.ip.service import IpService
            service = IpService()
            
            # 清理可能存在的测试IP
            cleanup_ips = []
            for i in range(5):
                cleanup_ips.append(f'192.168.30.{i+1}')
            for i in range(3):
                cleanup_ips.append(f'192.168.31.{i+1}')
            
            for ip in cleanup_ips:
                try:
                    service.delete_ip(ip)
                except:
                    pass
            
            # 创建测试IP
            test_ips = []
            asset_ids = ['2692be71-2cef-4b5d-9379-1e6f6033b7af', '46fd9b3b-a70a-48cf-95fc-f918c94fbfd9']
            for i in range(5):
                ip_data = {
                    'ip': f'192.168.30.{i+1}',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN30',
                    'purpose': '管理',
                    'status': '使用中',
                    'allocation_duration': '永久',
                    'asset_id': asset_ids[i % len(asset_ids)]  # 轮流使用两个资产ID
                }
                result = service.create_ip(ip_data)
                if result['success']:
                    test_ips.append(ip_data['ip'])
            
            if len(test_ips) < 5:
                logger.error("批量测试IP创建失败")
                return False
            
            # 测试批量更新状态
            result = service.batch_update_status(test_ips, '预留')
            if not result['success'] or result['updated_count'] != len(test_ips):
                logger.error(f"批量更新状态失败: {result}")
                return False
            
            # 验证批量更新结果
            for ip in test_ips:
                ip_data = service.get_ip_by_ip(ip)
                if ip_data['status'] != '预留':
                    logger.error(f"批量更新验证失败: {ip}")
                    return False
            
            # 测试批量导入
            import_data = []
            for i in range(3):
                ip_data = {
                    'ip': f'192.168.31.{i+1}',
                    'subnet_mask': '255.255.255.0',
                    'vlan': 'VLAN31',
                    'purpose': '业务',
                    'status': '使用中',
                    'allocation_duration': '永久',
                    'asset_id': asset_ids[i % len(asset_ids)]  # 轮流使用两个资产ID
                }
                import_data.append(ip_data)
            
            result = service.import_ips(import_data)
            if not result['success'] or result['success_count'] != len(import_data):
                logger.error(f"批量导入失败: {result}")
                return False
            
            # 清理测试数据
            all_test_ips = test_ips + [ip['ip'] for ip in import_data]
            for ip in all_test_ips:
                try:
                    service.delete_ip(ip)
                except:
                    pass
            
            logger.info("批量操作测试通过")
            return True
            
        except Exception as e:
            logger.error(f"批量操作测试失败: {e}")
            return False
    
    def test_error_handling(self):
        """测试错误处理"""
        try:
            from src.app.modules.ip.service import IpService
            from src.app.modules.ip.utils import IpUtils
            service = IpService()
            utils = IpUtils()
            
            # 测试1: 创建重复IP
            ip_data = self.test_data['valid_ips'][0].copy()
            ip_data['ip'] = '192.168.50.50'
            
            result1 = service.create_ip(ip_data)
            if not result1['success']:
                logger.error("创建测试IP失败")
                return False
            
            result2 = service.create_ip(ip_data)
            if result2['success']:
                logger.error("创建重复IP应该失败")
                return False
            
            # 测试2: 更新不存在的IP
            result = service.update_ip('192.168.50.99', {'status': '预留'})
            if result['success']:
                logger.error("更新不存在的IP应该失败")
                return False
            
            # 测试3: 删除不存在的IP
            result = service.delete_ip('192.168.50.99')
            if result['success']:
                logger.error("删除不存在的IP应该失败")
                return False
            
            # 测试4: 无效数据验证
            invalid_data = {
                'ip': 'invalid.ip',
                'subnet_mask': '255.255.255.0',
                'vlan': 'VLAN10',
                'purpose': '管理',
                'status': '使用中',
                'allocation_duration': '永久'
            }
            
            is_valid, error_msg = utils.validate_ip_data(invalid_data)
            if is_valid:
                logger.error("无效数据验证应该失败")
                return False
            
            # 清理测试数据
            try:
                service.delete_ip(ip_data['ip'])
            except:
                pass
            
            logger.info("错误处理测试通过")
            return True
            
        except Exception as e:
            logger.error(f"错误处理测试失败: {e}")
            return False
    
    def run_all_tests(self):
        """运行所有测试"""
        logger.info("开始IP管理模块回归测试")
        logger.info("=" * 60)
        
        # 运行所有测试
        self.run_test("模块导入测试", self.test_import_modules)
        self.run_test("工具类验证功能测试", self.test_utils_validation)
        self.run_test("缓存操作测试", self.test_cache_operations)
        self.run_test("服务层CRUD操作测试", self.test_service_crud_operations)
        self.run_test("实体绑定功能测试", self.test_entity_binding)
        self.run_test("外键约束测试", self.test_foreign_key_constraints)
        self.run_test("批量操作测试", self.test_batch_operations)
        self.run_test("错误处理测试", self.test_error_handling)
        
        # 生成测试报告
        self.generate_test_report()
    
    def generate_test_report(self):
        """生成测试报告"""
        logger.info("=" * 60)
        logger.info("IP管理模块回归测试报告")
        logger.info("=" * 60)
        
        total_tests = len(self.test_results)
        passed_tests = len([r for r in self.test_results if r['status'] == 'PASS'])
        failed_tests = len([r for r in self.test_results if r['status'] == 'FAIL'])
        error_tests = len([r for r in self.test_results if r['status'] == 'ERROR'])
        
        logger.info(f"总测试数: {total_tests}")
        logger.info(f"通过: {passed_tests}")
        logger.info(f"失败: {failed_tests}")
        logger.info(f"错误: {error_tests}")
        logger.info(f"成功率: {(passed_tests/total_tests*100):.1f}%")
        
        total_duration = sum(r['duration'] for r in self.test_results)
        logger.info(f"总耗时: {total_duration:.2f}秒")
        
        logger.info("-" * 60)
        logger.info("详细结果:")
        
        for result in self.test_results:
            status_icon = {
                'PASS': '✅',
                'FAIL': '❌',
                'ERROR': '💥'
            }.get(result['status'], '❓')
            
            logger.info(f"{status_icon} {result['name']}: {result['status']} ({result['duration']:.2f}s)")
            if result['status'] != 'PASS':
                logger.info(f"   错误信息: {result['message']}")
        
        logger.info("=" * 60)
        
        # 保存测试报告到文件
        with open('ip_regression_test_report.txt', 'w', encoding='utf-8') as f:
            f.write("IP管理模块回归测试报告\n")
            f.write("=" * 60 + "\n")
            f.write(f"测试时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
            f.write(f"总测试数: {total_tests}\n")
            f.write(f"通过: {passed_tests}\n")
            f.write(f"失败: {failed_tests}\n")
            f.write(f"错误: {error_tests}\n")
            f.write(f"成功率: {(passed_tests/total_tests*100):.1f}%\n")
            f.write(f"总耗时: {total_duration:.2f}秒\n")
            f.write("-" * 60 + "\n")
            f.write("详细结果:\n")
            
            for result in self.test_results:
                f.write(f"{result['status']}: {result['name']} ({result['duration']:.2f}s)\n")
                if result['status'] != 'PASS':
                    f.write(f"  错误信息: {result['message']}\n")
        
        logger.info("测试报告已保存到: ip_regression_test_report.txt")
        
        return failed_tests == 0 and error_tests == 0


if __name__ == '__main__':
    # 运行回归测试
    test = IpRegressionTest()
    success = test.run_all_tests()
    
    if success:
        logger.info("🎉 所有测试通过！IP管理模块回归测试成功。")
        sys.exit(0)
    else:
        logger.error("❌ 测试失败！请检查错误信息并修复问题。")
        sys.exit(1)
